Section: New Results

Programming support for Autonomic Computing

Reactive languages

Participants : Gwenaël Delaval, Eric Rutten.

Our work in reactive programming for autonomic computing systems is focused on the specification and compilation of declarative control objectives, under the form of contracts, enforced upon classical mode automata as defined in synchronous languages. The compilation involves a phase of Discrete Controller Synthesis in order to obtain an imperative executable code. The programming language Heptagon / BZR (see Section Software and Platforms) integrates our research results [7].

Recent work concerns exploring new possibilities offered by logics-numeric control. We target the problem of the safe control of reconfigurations in component-based software systems (see also Section 6.1.2 for the component-based aspects), where strategies of adaptation to variations in both their environment and internal resource demands need to be enforced. In this context, the computing system involves software components that are subject to control decisions. We approach this problem under the angle of Discrete Event Systems (DES), involving properties on events observed during the execution (e.g., requests of computing tasks, work overload), and a state space representing different configurations such as activity or assemblies of components. We consider in particular the potential of applying novel logico-numerical control techniques to extend the expressivity of control models and objectives, thereby extending the application of DES in component-based software systems. We elaborate methodological guidelines for the application of logico-numerical control based on a case-study, and validate the result experimentally.

This work is in cooperation with the Sumo team at Inria Rennes and University of Liverpool, and is published in the CCTA 2017 conference [15].

Component-based approaches

Participants : Gwenaël Delaval, Eric Rutten.

Our work in component-based programming for autonomic computing systems as examplified by e.g., Fractal , considers essentially the problem of specifying the control of components assembly reconfiguration, with an approach based on the integration within such a component-based framework of a reactive language as in Section 6.1.1 [6].

Dynamic reconfiguration is a key capability of Component-based Software Systems to achieve self-adaptation as it provides means to cope with environment changes at runtime. The space of configurations is defined by the possible assemblies of components, and navigating this space while achieving goals and maintaining structural properties is managed in an autonomic loop. The natural architectural structure of component-based systems calls for hierarchy and modularity in the design and implementation of composites and their managers, and requires support for coordinated multiple autonomic loops. [1] [12].

In recent work, we leverage the modularity capability to strengthen the Domain-Specific Language (DSL) Ctrl-F, targeted at the design of autonomic managers in component-based systems. Its original definition involved discrete control-theoretical management of reconfigurations, providing assurances on the automated behaviors. The objective of modularity is two-fold: from the design perspective, it allows designers to seamlessly decompose a complex system into smaller pieces of reusable architectural elements and adaptive behaviours. From the compilation point of view, we provide a systematical and generative approach to decompose control problems described in the architectural level while relying on mechanisms of modular Discrete Control Synthesis (DCS), which allows us to cope with the combinatorial complexity that is inherent to DCS problems. We show the applicability of our approach by applying it to the self-adaptive case study of the existing RUBiS/Brownout eBay-like web auction system.

This work is done in cooperation with Inria teams ASCOLA in Nantes and SPIRALS in Lille, and is published in the Journal of Systems and Software [12] and the SeAC 2017 - 2nd Workshop on Self-Aware Computing, a satellite of the ICAC’17 conference [14].

We are also considering integration at the DSL level of expressivity extensions, for which the compilation and controller synthesis is relying on the ReaX tool developed at Inria Rennes, in the Sumo team as mentioned in Section 6.1.1 [15].

Rule-based systems

Participants : Adja Sylla, Gwenaël Delaval, Eric Rutten.

This work concerns a high-level language for safe rule-based programming in the LINC transactional rule-based platform developed at CEA [17]. Rule based middlewares such as LINC enable high level programming of distributed adaptive systems behaviours. LINC also provides the systems with transactional guarantees and hence ensures their reliability at runtime. However, the set of rules may contain design errors (e.g. conflicts, violations of constraints) that can bring the system in unsafe safe or undesirables states, despite the guarantees provided by LINC. On the other hand, automata based languages such as Heptagon/BZR enable formal verification and especially synthesis of discrete controllers to deal with design errors. Our work studies these two languages and combines their execution mechanisms, from a technical perspective. We target applications to the domain of Internet of Things and more particularly smart building, office or home (see Section 6.2.2.1).

This work is in cooperation with CEA LETI/DACLE, it is the topic of the PhD of Adja Sylla at CEA, co-advised with M. Louvel [11], and aspects on Software Engineering and Software Architecture for Multiple Autonomic Loops are published in the ICCAC 2017 conference [18].

A Language for the Smart Home

Participant : Gwenaël Delaval.

This work is about the design of the CCBL programming language (Cascading Contexts Based Language), an end-user programming language dedicated to Smart Home. CCBL has been proposed to avoid the problems encountered by end-users programming with ECA (Event Conditions Actions), which is the dominant approach in the field. This language has been evaluated by means of a user-based experiment where 21 adults (11 experimented programmers and 10 non-programmers) have been asked to express four increasingly complex behaviors using both CCBL and ECA. It has been shown that significantly less errors were made using CCBL than using ECA. From this experiment, some categorization and explanation of the errors made when using ECA have been proposed, with explanations about why users avoid these errors when programming with CCBL. Finally, error reporting for CCBL have been explored by identifying two specific errors and by developing a solution based on Heptagon and ReaX to detect them in CCBL programs.

This work is done in cooperation with the IIHM team of LIG (Alexandre Demeure), in the framework of a LIG « projet émergence » and was the topic of the MSc internship of Lénaïg Terrier [22].